home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2002 #11 / Amiga Plus CD - 2002 - No. 11.iso / Tools / Development / TinyGL / ami / content / ad709 / tinygl / src / ztriangle.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-08-18  |  9.6 KB  |  299 lines
  1. /*$T ztriangle.c GC 1.137 08/09/02 17:47:17 */
  2.  
  3. /*$6
  4.  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  5.  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  6.  */
  7.  
  8. #include "ztriangle.h"
  9.  
  10. float    srcAlpha;
  11. int        src_r, src_g, src_b;
  12. int        des_r, des_g, des_b;
  13. int        alp_r, alp_g, alp_b;
  14. put_pixel_t __put_pixel;
  15.  
  16.  
  17. void alphaBlend() {
  18.     alp_b = srcAlpha * src_b + (1 - srcAlpha) * des_b;
  19.     alp_g = srcAlpha * src_g + (1 - srcAlpha) * des_g;
  20.     alp_r = srcAlpha * src_r + (1 - srcAlpha) * des_r;
  21. }
  22.  
  23.  
  24.  
  25. /*  ==============================================================
  26.     16 bit SMOOTH SHADING 
  27.     ==============================================================
  28. */
  29.  
  30. void draw_init_16_sm(int *_drgbdx, int drdx, int dgdx, int dbdx, int *color, ZBufferPoint *p2,
  31.                      float *fdzdx, float *fndzdx, float *ndszdx, float *ndtzdx, PIXEL *texture,
  32.                      float *dszdx, float *dtzdx, ZBuffer *zb, int dzdx) {
  33.     (*_drgbdx) = (SAR_RND_TO_ZERO(drdx, 6) << 22) & 0xFFC00000;
  34.     (*_drgbdx) |= SAR_RND_TO_ZERO(dgdx, 5) & 0x000007FF;
  35.     (*_drgbdx) |= (SAR_RND_TO_ZERO(dbdx, 7) << 12) & 0x001FF000;
  36. }
  37.  
  38. /* */
  39. void put_pixel_16_sm(int _a, int *zz, PIXEL *pp, int *tmp, int *rgb, int drgbdx, int *z,
  40.                      unsigned short *pz, int dzdx, int color, PIXEL *texture, unsigned int *s,
  41.                      unsigned int *t, int dsdx, int dtdx) {
  42.     *zz = (*z) >> ZB_POINT_Z_FRAC_BITS;
  43.     if(ZCMP(*zz, pz[_a])) {
  44.         *tmp = (*rgb) & 0xF81F07E0;
  45.         pp[_a] = (*tmp) | ((*tmp) >> 16);
  46.         pz[_a] = *zz;
  47.     }
  48.     (*z) += dzdx;
  49.     *rgb = (*rgb + drgbdx) & (~0x00200800);
  50. }
  51.  
  52. /* */
  53. void put_pixel_16_sm_bl(int _a, int *zz, PIXEL *pp, int *tmp, int *rgb, int drgbdx, int *z,
  54.                         unsigned short *pz, int dzdx, int color, PIXEL *texture, unsigned int *s,
  55.                         unsigned int *t, int dsdx, int dtdx) {
  56.     int srcColor;
  57.     *zz = (*z) >> ZB_POINT_Z_FRAC_BITS;
  58.     if(ZCMP(*zz, pz[_a])) {
  59.         *tmp = (*rgb) & 0xF81F07E0;
  60.         srcColor = (*tmp) | ((*tmp) >> 16);
  61.         PIXEL_TO_RGB(pp[_a], des_r, des_g, des_b);
  62.         PIXEL_TO_RGB(srcColor, src_r, src_g, src_b);
  63.         alphaBlend();
  64.         pp[_a] = RGB_TO_PIXEL(alp_r, alp_g, alp_b);
  65.         pz[_a] = *zz;
  66.     }
  67.     (*z) += dzdx;
  68.     *rgb = (*rgb + drgbdx) & (~0x00200800);
  69. }
  70.  
  71. /* */
  72. void draw_line_16_sm(int dzdx, int _drgbdx, int r1, int g1, int b1, unsigned short *pz1, PIXEL *pp1,
  73.                      int x1, int x2, int z1, float sz1, float tz1, float dszdx, float dtzdx,
  74.                      float fdzdx, float fndzdx, float ndszdx, float ndtzdx, PIXEL *texture) {
  75.     unsigned short    *pz;
  76.     PIXEL            *pp;
  77.     unsigned int    tmp, z, zz, rgb, drgbdx;
  78.     int                n;
  79.     n = (x2 >> 16) - x1;
  80.     pp = pp1 + x1;
  81.     pz = pz1 + x1;
  82.     z = z1;
  83.     rgb = (r1 << 16) & 0xFFC00000;
  84.     rgb |= (g1 >> 5) & 0x000007FF;
  85.     rgb |= (b1 << 5) & 0x001FF000;
  86.     drgbdx = _drgbdx;
  87.     while(n >= 3) {
  88.         __put_pixel(0, &zz, pp, &tmp, &rgb, drgbdx, &z, pz, dzdx, 0, NULL, &tmp, &tmp, tmp, tmp);
  89.         __put_pixel(1, &zz, pp, &tmp, &rgb, drgbdx, &z, pz, dzdx, 0, NULL, &tmp, &tmp, tmp, tmp);
  90.         __put_pixel(2, &zz, pp, &tmp, &rgb, drgbdx, &z, pz, dzdx, 0, NULL, &tmp, &tmp, tmp, tmp);
  91.         __put_pixel(3, &zz, pp, &tmp, &rgb, drgbdx, &z, pz, dzdx, 0, NULL, &tmp, &tmp, tmp, tmp);
  92.         pz += 4;
  93.         pp += 4;
  94.         n -= 4;
  95.     }
  96.  
  97.     while(n >= 0) {
  98.         __put_pixel(0, &zz, pp, &tmp, &rgb, drgbdx, &z, pz, dzdx, 0, NULL, &tmp, &tmp, tmp, tmp);
  99.         pz++;
  100.         pp++;
  101.         n--;
  102.     }
  103. }
  104.  
  105.  
  106.  
  107.  
  108. /*  ==============================================================
  109.     16 bit FLAT SHADING 
  110.     ==============================================================
  111. */
  112.  
  113. void draw_init_16_fl(int *_drgbdx, int drdx, int dgdx, int dbdx, int *color, ZBufferPoint *p2,
  114.                      float *fdzdx, float *fndzdx, float *ndszdx, float *ndtzdx, PIXEL *texture,
  115.                      float *dszdx, float *dtzdx, ZBuffer *zb, int dzdx) {
  116.     *color = RGB_TO_PIXEL(p2->r, p2->g, p2->b);
  117. }
  118.  
  119. /* */
  120. void put_pixel_16_fl(int _a, int *zz, PIXEL *pp, int *tmp, int *rgb, int drgbdx, int *z,
  121.                      unsigned short *pz, int dzdx, int color, PIXEL *texture, unsigned int *s,
  122.                      unsigned int *t, int dsdx, int dtdx) {
  123.     *zz = (*z) >> ZB_POINT_Z_FRAC_BITS;
  124.     if(ZCMP(*zz, pz[_a])) {
  125.         pp[_a] = color;
  126.         pz[_a] = *zz;
  127.     }
  128.     (*z) += dzdx;
  129. }
  130.  
  131. /* */
  132. void put_pixel_16_fl_bl(int _a, int *zz, PIXEL *pp, int *tmp, int *rgb, int drgbdx, int *z,
  133.                         unsigned short *pz, int dzdx, int color, PIXEL *texture, unsigned int *s,
  134.                         unsigned int *t, int dsdx, int dtdx) {
  135.     *zz = (*z) >> ZB_POINT_Z_FRAC_BITS;
  136.  
  137.     if(ZCMP(*zz, pz[_a])) {
  138.         PIXEL_TO_RGB(pp[_a], des_r, des_g, des_b);
  139.         alphaBlend();
  140.         pp[_a] = RGB_TO_PIXEL(alp_r, alp_g, alp_b);
  141.         pz[_a] = *zz;
  142.     }
  143.     (*z) += dzdx;
  144. }
  145.  
  146.  
  147.  
  148.  
  149. /*  ==============================================================
  150.     16 bit TEXTURE MAPPING 
  151.     ==============================================================
  152. */
  153.  
  154. void draw_init_16_mp(int *_drgbdx, int drdx, int dgdx, int dbdx, int *color, ZBufferPoint *p2,
  155.                      float *fdzdx, float *fndzdx, float *ndszdx, float *ndtzdx, PIXEL *texture,
  156.                      float *dszdx, float *dtzdx, ZBuffer *zb, int dzdx) {
  157.     texture = zb->current_texture;
  158.     *fdzdx = (float) dzdx;
  159.     *fndzdx = NB_INTERP * (*fdzdx);
  160.     *ndszdx = NB_INTERP * (*dszdx);
  161.     *ndtzdx = NB_INTERP * (*dtzdx);
  162. }
  163.  
  164. /* */
  165. void put_pixel_16_mp(int _a, int *zz, PIXEL *pp, int *tmp, int *rgb, int drgbdx, int *z,
  166.                      unsigned short *pz, int dzdx, int color, PIXEL *texture, unsigned int *s,
  167.                      unsigned int *t, int dsdx, int dtdx) {
  168.     *zz = (*z) >> ZB_POINT_Z_FRAC_BITS;
  169.     if(ZCMP(*zz, pz[_a])) {
  170.         pp[_a] = *(PIXEL *) ((char *) texture + ((((*t) & 0x3FC00000) | ((*s) & 0x003FC000)) >> (17 - PSZSH)));
  171.         pz[_a] = *zz;
  172.     }
  173.     (*z) += dzdx;
  174.     (*s) += dsdx;
  175.     (*t) += dtdx;
  176. }
  177.  
  178. /* */
  179. void draw_line_16_mp(int dzdx, int _drgbdx, int r1, int g1, int b1, unsigned short *pz1, PIXEL *pp1,
  180.                      int x1, int x2, int z1, float sz1, float tz1, float dszdx, float dtzdx,
  181.                      float fdzdx, float fndzdx, float ndszdx, float ndtzdx, PIXEL *texture) {
  182.     register unsigned short *pz;
  183.     register PIXEL            *pp;
  184.     unsigned int            s, t, z, zz;
  185.     int                        n, dsdx, dtdx;
  186.     float                    sz, tz, fz, zinv;
  187.  
  188.     n = (x2 >> 16) - x1;
  189.     fz = (float) z1;
  190.     zinv = 1.0 / fz;
  191.     pp = (PIXEL *) ((char *) pp1 + x1 * PSZB);
  192.     pz = pz1 + x1;
  193.     z = z1;
  194.     sz = sz1;
  195.     tz = tz1;
  196.     while(n >= (NB_INTERP - 1)) { {
  197.             float    ss, tt;
  198.             ss = (sz * zinv);
  199.             tt = (tz * zinv);
  200.             s = (int) ss;
  201.             t = (int) tt;
  202.             dsdx = (int) ((dszdx - ss * fdzdx) * zinv);
  203.             dtdx = (int) ((dtzdx - tt * fdzdx) * zinv);
  204.             fz += fndzdx;
  205.             zinv = 1.0 / fz;
  206.         }
  207.  
  208.         put_pixel_16_mp(0, &zz, pp, NULL, NULL, 0, &z, pz, dzdx, 0, texture, &s, &t, dsdx, dtdx);
  209.         put_pixel_16_mp(1, &zz, pp, NULL, NULL, 0, &z, pz, dzdx, 0, texture, &s, &t, dsdx, dtdx);
  210.         put_pixel_16_mp(2, &zz, pp, NULL, NULL, 0, &z, pz, dzdx, 0, texture, &s, &t, dsdx, dtdx);
  211.         put_pixel_16_mp(3, &zz, pp, NULL, NULL, 0, &z, pz, dzdx, 0, texture, &s, &t, dsdx, dtdx);
  212.         put_pixel_16_mp(4, &zz, pp, NULL, NULL, 0, &z, pz, dzdx, 0, texture, &s, &t, dsdx, dtdx);
  213.         put_pixel_16_mp(5, &zz, pp, NULL, NULL, 0, &z, pz, dzdx, 0, texture, &s, &t, dsdx, dtdx);
  214.         put_pixel_16_mp(6, &zz, pp, NULL, NULL, 0, &z, pz, dzdx, 0, texture, &s, &t, dsdx, dtdx);
  215.         put_pixel_16_mp(7, &zz, pp, NULL, NULL, 0, &z, pz, dzdx, 0, texture, &s, &t, dsdx, dtdx);
  216.  
  217.         pz += NB_INTERP;
  218.         pp = (PIXEL *) ((char *) pp + NB_INTERP * PSZB);
  219.         n -= NB_INTERP;
  220.         sz += ndszdx;
  221.         tz += ndtzdx;
  222.     } {
  223.         float    ss, tt;
  224.         ss = (sz * zinv);
  225.         tt = (tz * zinv);
  226.         s = (int) ss;
  227.         t = (int) tt;
  228.         dsdx = (int) ((dszdx - ss * fdzdx) * zinv);
  229.         dtdx = (int) ((dtzdx - tt * fdzdx) * zinv);
  230.     }
  231.  
  232.     while(n >= 0) {
  233.         put_pixel_16_mp(0, &zz, pp, NULL, NULL, 0, &z, pz, dzdx, 0, texture, &s, &t, dsdx, dtdx);
  234.         pz += 1;
  235.         pp = (PIXEL *) ((char *) pp + PSZB);
  236.         n -= 1;
  237.     }
  238. }
  239.  
  240.  
  241.  
  242.  
  243. /* Flat shaded triangle */
  244. void ZB_fillTriangleFlat(ZBuffer *zb, ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2) {
  245.     int color = 0;
  246.  
  247.     renderTriangle(zb, p0, p1, p2, color, 0, NULL, 0, 0, 0, 0, 1, 0, 0, 0, draw_init_16_fl,
  248.                        put_pixel_16_fl, NULL);
  249. }
  250.  
  251. /* Flat shaded triangle with blending*/
  252. void ZB_fillTriangleFlatBlend(ZBuffer *zb, ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2,
  253.                               float alpha) {
  254.     int color = 0;
  255.     srcAlpha = alpha;
  256.     src_r = p2->r;
  257.     src_g = p2->g;
  258.     src_b = p2->b;
  259.     
  260.     renderTriangle(zb, p0, p1, p2, color, 0, NULL, 0, 0, 0, 0, 1, 0, 0, 0, draw_init_16_fl,
  261.                        put_pixel_16_fl_bl, NULL);
  262. }
  263.  
  264. /* Smooth filled triangle. */
  265. void ZB_fillTriangleSmooth(ZBuffer *zb, ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2) {
  266.     int _drgbdx = 0;
  267.     __put_pixel = put_pixel_16_sm;
  268.     renderTriangle(zb, p0, p1, p2, 0, _drgbdx, NULL, 0, 0, 0, 0, 1, 1, 0, 0, draw_init_16_sm,
  269.                        put_pixel_16_sm, draw_line_16_sm);
  270. }
  271.  
  272. /* Smooth filled triangle with blending */
  273. void ZB_fillTriangleSmoothBlend(ZBuffer *zb, ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2,
  274.                                 float alpha) {
  275.     int _drgbdx = 0;
  276.     srcAlpha = alpha;
  277.     __put_pixel = put_pixel_16_sm_bl;
  278.     renderTriangle(zb, p0, p1, p2, 0, _drgbdx, NULL, 0, 0, 0, 0, 1, 1, 0, 0, draw_init_16_sm,
  279.                        put_pixel_16_sm_bl, draw_line_16_sm);
  280. }
  281.  
  282. /*
  283.  * Texture mapped triangle with perspective correction. We use the gradient method to make
  284.  * less divisions. TODO: pipeline the division
  285.  */
  286. void ZB_fillTriangleMappingPerspective(ZBuffer *zb, ZBufferPoint *p0, ZBufferPoint *p1,
  287.                                        ZBufferPoint *p2) {
  288.     PIXEL    *texture = zb->current_texture;
  289.     float    fdzdx = 0, fndzdx = 0, ndszdx = 0, ndtzdx = 0;
  290.  
  291.     renderTriangle(zb, p0, p1, p2, 0, 0, texture, fdzdx, fndzdx, ndszdx, ndtzdx, 1, 0, 0, 1,
  292.                        draw_init_16_mp, put_pixel_16_mp, draw_line_16_mp);
  293. }
  294.  
  295.  
  296. void ZB_setTexture(ZBuffer *zb, PIXEL *texture) {
  297.     zb->current_texture = texture;
  298. }
  299.